Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume23/xenix-gnu/part03

Text File | 1991-09-27 | 49.9 KB | 1,822 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Steve Bleazard)
Subject:  v23i030:  xenix-gnu - Xenix 386 patchkit for GCC / GAS and GDB, Part03/03
Message-ID: <[e-mail]>
X-Md4-Signature: 45d481dc5fe1fd86ac9803d3ae052d4e
Date: Fri, 27 Sep 1991 05:00:11 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Steve Bleazard)
Posting-number: Volume 23, Issue 30
Archive-name: xenix-gnu/part03
Environment: SCOXENIX

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to [e-mail] if you want that tool.
# Contents:  gas-1.38.pch
# Wrapped by kent@sparky on Thu Sep 26 23:27:44 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive."'
if test -f 'gas-1.38.pch' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'gas-1.38.pch'\"
else
  echo shar: Extracting \"'gas-1.38.pch'\" \(47292 characters\)
  sed "s/^X//" >'gas-1.38.pch' <<'END_OF_FILE'
X*** gas-1.38/Makefile    Thu Oct 18 15:26:42 1990
X--- Makefile    Fri Jul 12 06:02:10 1991
X***************
X*** 50,55 ****
X--- 50,61 ----
X  # and un-comment the next two lines.
X  # G0 = -g -I. -DUSE_SYSTEM_HDR -DEXEC_VERSION=1
X  # LOADLIBES = -lc /usr/att/lib/libc.a
X+ #
X+ # To compile gas for a Xenix 386, comment out all the above lines,
X+ # and un-comment the next two lines.  (If you are using GCC, comment out the
X+ # alloca.o part) (Get alloca from the emacs distribution, or use GCC.)
X+ G0 = -O -I. -DUSG -DWORKING_DOT_WORD
X+ LOADLIBES = alloca.o -lmalloc
X
X  # If you just want to compile the vax assembler, type 'make avax'
X
X***************
X*** 129,134 ****
X--- 135,144 ----
X  CFLAGS = $(G0) $(G1) $(G2) $(G3) $(G4)
X
X  #
X+ #
X+ # To make the XENIX 386 assembler compile as the default, un-comment the next
X+ # line and commment out all the other lines that start with DEFAULT_GAS
X+ #DEFAULT_GAS=ax386
X  # To make the 68020 assembler compile as the default, un-comment the next
X  # line, and comment out all the other lines that start with DEFAULT_GAS
X  DEFAULT_GAS=a68
X***************
X*** 245,250 ****
X--- 255,269 ----
X
X  a386: $a $x
X      $(CC) -o a386 $(LDFLAGS) $a $x $(LOADLIBES)
X+
X+ # XENIX 80386 GAS --------------------------------------------------------------
X+ u = xenixomf.o omfwrite.o
X+ U = xenixomf.c xenixomf.h msomf.h omfwrite.c
X+
X+ xenixomf.o:    xenixomf.h msomf.h
X+
X+ ax386: $a $x $u
X+     $(CC) -o ax386 $(LDFLAGS) $a $u $x $(LOADLIBES)
X
X  # 68020 GAS ------------------------------------------------------------------
X  y = m68k.o  atof-ieee.o write.o read.o
X*** gas-1.38/as.c    Thu Oct 11 11:26:17 1990
X--- as.c    Wed Jul 10 09:01:54 1991
X***************
X*** 84,89 ****
X--- 84,90 ----
X      myname=argv[0];
X      bzero (flagseen, sizeof(flagseen)); /* aint seen nothing yet */
X      out_file_name    = "a.out";    /* default .o file */
X+     module_name = "unknown.s";
X      symbol_begin();        /* symbols.c */
X      subsegs_begin();        /* subsegs.c */
X      read_begin();            /* read.c */
X*** gas-1.38/as.h    Thu Oct 11 11:26:18 1990
X--- as.h    Wed Jul 10 09:01:58 1991
X***************
X*** 286,291 ****
X--- 286,292 ----
X
X  COMMON int    need_pass_2;    /* TRUE if we need a second pass. */
X
X+ COMMON char *module_name;    /* Name given in the file directive */
X
X  #endif                /* #ifdef asH */
X
X*** gas-1.38/config.h
X--- config.h    Wed Jul 10 09:16:07 1991
X***************
X*** 0 ****
X--- 1 ----
X+ #define XENIX
X*** gas-1.38/msomf.h
X--- msomf.h    Wed Jul 10 09:02:22 1991
X***************
X*** 0 ****
X--- 1,24 ----
X+
X+ /* Segment indexes for segdefs */
X+
X+ #define SDEF_TEXT    1
X+ #define SDEF_DATA    2
X+ #define SDEF_CONST    3
X+ #define SDEF_BSS    4
X+ #define SDEF_SYMBOLS    5
X+ #define SDEF_TYPES    6
X+ #define SDEF_SIZE    4
X+ #define SDEF_G_SIZE    6
X+
X+ #define GDEF_DGROUP    1
X+
X+ #define I386        1
X+ #define FRAME_THREAD    1
X+ #define TARGET_THREAD    0
X+
X+ #define TEXT_FRAME_THREAD    0
X+ #define DGROUP_FRAME_THREAD    1
X+ #define CONST_TGT_THREAD    0
X+ #define DATA_TGT_THREAD        1
X+ #define TEXT_TGT_THREAD        2
X+ #define BSS_TGT_THREAD        3
X*** gas-1.38/omfwrite.c
X--- omfwrite.c    Wed Jul 10 09:02:24 1991
X***************
X*** 0 ****
X--- 1,672 ----
X+ /* write.c - emit .o file - Copyright(C)1986 Free Software Foundation, Inc.
X+    Copyright (C) 1986,1987 Free Software Foundation, Inc.
X+
X+ This file is part of GAS, the GNU Assembler.
X+
X+ GAS is free software; you can redistribute it and/or modify
X+ it under the terms of the GNU General Public License as published by
X+ the Free Software Foundation; either version 1, or (at your option)
X+ any later version.
X+
X+ GAS is distributed in the hope that it will be useful,
X+ but WITHOUT ANY WARRANTY; without even the implied warranty of
X+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
X+ GNU General Public License for more details.
X+
X+ You should have received a copy of the GNU General Public License
X+ along with GAS; see the file COPYING.  If not, write to
X+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
X+
X+ #include "as.h"
X+ #include "md.h"
X+ #include "subsegs.h"
X+ #include "obstack.h"
X+ #include "struc-symbol.h"
X+ #include "write.h"
X+ #include "symbols.h"
X+
X+ #include "xenixomf.h"
X+ #include "msomf.h"
X+
X+ #if __STDC__
X+ #include <stddef.h>
X+ #else
X+ #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
X+ #endif
X+
X+ void    append();
X+
X+ /*
X+  * In: length of relocation (or of address) in chars: 1, 2 or 4.
X+  * Out: OMF LOC type.
X+  */
X+
X+ static unsigned char nbytes_r_length [] = {
X+   15, LOC_LOBYTE, LOC_OFFSET, 15, LOC_OFFSET32
X+   };
X+
X+
X+ static struct frag *    text_frag_root;
X+ static struct frag *    data_frag_root;
X+
X+ static struct frag *    text_last_frag;    /* Last frag in segment. */
X+ static struct frag *    data_last_frag;    /* Last frag in segment. */
X+
X+ static struct exec    the_exec;
X+
X+ static long int string_byte_count;
X+ static long int stab_symbol_count;
X+
X+ void    relax_segment();
X+ long int    fixup_segment();
X+
X+ static void threads(type, trgt_thrd, frm_thrd)
X+ int type;
X+ int *trgt_thrd, *frm_thrd;
X+ {
X+       switch (type)
X+       {
X+         case PRIVDATA:    *trgt_thrd = DATA_TGT_THREAD;
X+                 *frm_thrd = DGROUP_FRAME_THREAD;
X+                 break;
X+         case PRIVBSS:    *trgt_thrd = BSS_TGT_THREAD;
X+                 *frm_thrd = DGROUP_FRAME_THREAD;
X+                 break;
X+         case PRIVTEXT:    *trgt_thrd = TEXT_TGT_THREAD;
X+                 *frm_thrd = TEXT_FRAME_THREAD;
X+                 break;
X+         case PUBLICDATA:    *trgt_thrd = DATA_TGT_THREAD;
X+                 *frm_thrd = DGROUP_FRAME_THREAD;
X+                 break;
X+         case PUBLICTEXT:    *trgt_thrd = TEXT_TGT_THREAD;
X+                 *frm_thrd = TEXT_FRAME_THREAD;
X+                 break;
X+         default:        *trgt_thrd = CONST_TGT_THREAD;
X+                 *frm_thrd = DGROUP_FRAME_THREAD;
X+                 break;
X+       }
X+ }
X+
X+ void
X+ write_object_file()
X+ {
X+   register struct frchain *    frchainP; /* Track along all frchains. */
X+   register fragS *        fragP;    /* Track along all frags. */
X+   register struct frchain *    next_frchainP;
X+   register fragS * *        prev_fragPP;
X+   register char *        name;
X+   register symbolS *        symbolP;
X+   register symbolS **        symbolPP;
X+   /* register fixS *        fixP; JF unused */
X+   unsigned long
X+       text_siz,
X+     data_siz,
X+     syms_siz,
X+     tr_siz,
X+     dr_siz;
X+   void output_file_create();
X+   void output_file_append();
X+   void output_file_close();
X+   extern long omagic;        /* JF magic # to write out.  Is different for
X+                    Suns and Vaxen and other boxes */
X+
X+   /*
X+    * After every sub-segment, we fake an ".align ...". This conforms to BSD4.2
X+    * brane-damage. We then fake ".fill 0" because that is the kind of frag
X+    * that requires least thought. ".align" frags like to have a following
X+    * frag since that makes calculating their intended length trivial.
X+    */
X+ #define SUB_SEGMENT_ALIGN (2)
X+   for ( frchainP=frchain_root; frchainP; frchainP=frchainP->frch_next )
X+     {
X+       subseg_new (frchainP -> frch_seg, frchainP -> frch_subseg);
X+       frag_align (SUB_SEGMENT_ALIGN, 0);
X+                 /* frag_align will have left a new frag. */
X+                 /* Use this last frag for an empty ".fill". */
X+       /*
X+        * For this segment ...
X+        * Create a last frag. Do not leave a "being filled in frag".
X+        */
X+       frag_wane (frag_now);
X+       frag_now -> fr_fix    = 0;
X+       know( frag_now -> fr_next == NULL );
X+       /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
X+       /* Above shows we haven't left a half-completed object on obstack. */
X+     }
X+
X+   /*
X+    * From now on, we don't care about sub-segments.
X+    * Build one frag chain for each segment. Linked thru fr_next.
X+    * We know that there is at least 1 text frchain & at least 1 data frchain.
X+    */
X+   prev_fragPP = &text_frag_root;
X+   for ( frchainP=frchain_root; frchainP; frchainP=next_frchainP )
X+     {
X+       know( frchainP -> frch_root );
X+       * prev_fragPP = frchainP -> frch_root;
X+       prev_fragPP = & frchainP -> frch_last -> fr_next;
X+       if (   ((next_frchainP = frchainP->frch_next) == NULL)
X+       || next_frchainP == data0_frchainP)
X+     {
X+       prev_fragPP = & data_frag_root;
X+       if ( next_frchainP )
X+         {
X+           text_last_frag = frchainP -> frch_last;
X+         }
X+       else
X+         {
X+           data_last_frag = frchainP -> frch_last;
X+         }
X+     }
X+     }                /* for(each struct frchain) */
X+
X+   relax_segment (text_frag_root, SEG_TEXT);
X+   relax_segment (data_frag_root, SEG_DATA);
X+   /*
X+    * Now the addresses of frags are correct within the segment.
X+    */
X+
X+   text_siz=text_last_frag->fr_address;
X+
X+   /*
X+    *
X+    * Determine a_data [length of data segment].
X+    */
X+   if (data_frag_root)
X+       data_siz=data_last_frag->fr_address;
X+   else
X+       data_siz = 0;
X+
X+   bss_address_frag . fr_address = 0;
X+
X+   /*
X+    *
X+    * Crawl the symbol chain.
X+    *
X+    * For each symbol whose value depends on a frag, take the address of
X+    * that frag and subsume it into the value of the symbol.
X+    * After this, there is just one way to lookup a symbol value.
X+    * Values are left in their final state for object file emission.
X+    * We adjust the values of 'L' local symbols, even if we do
X+    * not intend to emit them to the object file, because their values
X+    * are needed for fix-ups.
X+    *
X+    * Unless we saw a -L flag, remove all symbols that begin with 'L'
X+    * from the symbol chain.
X+    *
X+    * Count the (length of the nlists of the) (remaining) symbols.
X+    * Assign a symbol number to each symbol.
X+    * Count the number of string-table chars we will emit.
X+    *
X+    */
X+   string_byte_count = sizeof( string_byte_count );
X+
X+   /* JF deal with forward references first. . . */
X+   for(symbolP=symbol_rootP;symbolP;symbolP=symbolP->sy_next) {
X+       if(symbolP->sy_forward) {
X+         symbolP->sy_value+=symbolP->sy_forward->sy_value+symbolP->sy_forward->sy_frag->fr_address;
X+         symbolP->sy_forward=0;
X+     }
X+   }
X+   symbolPP = & symbol_rootP;    /* -> last symbol chain link. */
X+   {
X+     register long int        symbol_number;
X+
X+     symbol_number = 1;  stab_symbol_count = 0;
X+
X+     while (symbolP  = * symbolPP)
X+       {
X+     name = symbolP -> sy_name;
X+     symbolP -> sy_value += symbolP -> sy_frag -> fr_address;
X+     if ( !name || (symbolP->sy_nlist.n_type&N_STAB)
X+         || (name[0]!='\001' && (flagseen ['L'] || name [0] != 'L' )))
X+       {
X+         if (EXTDEF(symbolP->sy_nlist.n_type))
X+             symbolP -> sy_number = symbol_number ++;
X+         else
X+             symbolP -> sy_number = 0;
X+         if (symbolP->sy_nlist.n_type&N_STAB)
X+         stab_symbol_count++;
X+         if (name && symbolP->sy_nlist.n_type&N_STAB)
X+           {            /* Ordinary case. */
X+         symbolP -> sy_name_offset = string_byte_count;
X+         string_byte_count += strlen (symbolP  -> sy_name) + 1;
X+           }
X+         else            /* .Stabd case. */
X+         symbolP -> sy_name_offset = 0;
X+         symbolPP = & (symbolP -> sy_next);
X+       }
X+     else
X+         * symbolPP = symbolP -> sy_next;
X+       }                /* for each symbol */
X+
X+     syms_siz = sizeof( struct nlist) * symbol_number;
X+   }
X+
X+   /*
X+    * Addresses of frags now reflect addresses we use in the object file.
X+    * Symbol values are correct.
X+    * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
X+    * Also converting any machine-dependent frags using md_convert_frag();
X+    */
X+   subseg_change( SEG_TEXT, 0);
X+
X+   for (fragP = text_frag_root;  fragP;  fragP = fragP -> fr_next)
X+     {
X+       switch (fragP -> fr_type)
X+     {
X+     case rs_align:
X+     case rs_org:
X+       fragP -> fr_type = rs_fill;
X+       know( fragP -> fr_var == 1 );
X+       know( fragP -> fr_next );
X+       fragP -> fr_offset
X+         =     fragP -> fr_next -> fr_address
X+           -   fragP -> fr_address
X+         - fragP -> fr_fix;
X+       break;
X+
X+     case rs_fill:
X+       break;
X+
X+     case rs_machine_dependent:
X+       md_convert_frag (fragP);
X+       /*
X+        * After md_convert_frag, we make the frag into a ".space 0".
X+        * Md_convert_frag() should set up any fixSs and constants
X+        * required.
X+        */
X+       frag_wane (fragP);
X+       break;
X+
X+     default:
X+       BAD_CASE( fragP -> fr_type );
X+       break;
X+     }            /* switch (fr_type) */
X+     }                /* for each frag. */
X+
X+
X+   subseg_change( SEG_DATA, 0);
X+
X+   for (fragP = data_frag_root;  fragP;  fragP = fragP -> fr_next)
X+     {
X+       switch (fragP -> fr_type)
X+     {
X+     case rs_align:
X+     case rs_org:
X+       fragP -> fr_type = rs_fill;
X+       know( fragP -> fr_var == 1 );
X+       know( fragP -> fr_next );
X+       fragP -> fr_offset
X+         =     fragP -> fr_next -> fr_address
X+           -   fragP -> fr_address
X+         - fragP -> fr_fix;
X+       break;
X+
X+     case rs_fill:
X+       break;
X+
X+     case rs_machine_dependent:
X+       md_convert_frag (fragP);
X+       /*
X+        * After md_convert_frag, we make the frag into a ".space 0".
X+        * Md_convert_frag() should set up any fixSs and constants
X+        * required.
X+        */
X+       frag_wane (fragP);
X+       break;
X+
X+     default:
X+       BAD_CASE( fragP -> fr_type );
X+       break;
X+     }            /* switch (fr_type) */
X+     }                /* for each frag. */
X+
X+   subseg_change( SEG_TEXT, 0);
X+
X+   fixup_segment (text_fix_root, N_TEXT);
X+   fixup_segment (data_fix_root, N_DATA);
X+   output_file_create (out_file_name);
X+   omf_initialize_a_out(module_name, text_siz, data_siz,
X+                (long) local_bss_counter, 0L,
X+                flagseen['g'], stab_symbol_count * sizeof(struct nlist),
X+                string_byte_count);
X+
X+ /*  Traverse the symbol chain emitting external symbol definitions
X+  *  for external, public and common symbols.
X+  */
X+
X+   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
X+   {
X+       if (EXTDEF(symbolP->sy_type))
X+       {
X+           if (COMMDEF(symbolP->sy_type))
X+           {
X+               omf_start_comdef();
X+               omf_comdef(symbolP->sy_name, TD_CNEAR, symbolP->sy_value, 0L);
X+               omf_end_comdef();
X+           }
X+           else
X+               omf_extdef(symbolP->sy_name, 0);
X+       }
X+   }
X+
X+ /*  Traverse the symbol chain emitting public definitions
X+  */
X+
X+   for (   symbolP = symbol_rootP;   symbolP;   symbolP = symbolP -> sy_next   )
X+   {
X+     if (PUBLIC(symbolP->sy_type))
X+     {
X+         unsigned int group = 0, segment = 0;
X+
X+         if (symbolP->sy_type == PUBLICTEXT)
X+             segment = SDEF_TEXT;
X+         if (symbolP->sy_type == PUBLICDATA)
X+         {
X+             group = GDEF_DGROUP;  segment = SDEF_DATA;
X+         }
X+
X+         omf_start_pubdef(I386, group, segment, 0);
X+         omf_pubdef(I386, symbolP->sy_name, symbolP->sy_value, 0);
X+         omf_end_pubdef();
X+     }
X+   }
X+
X+
X+   /* Setup threads for DGROUP and the segments ready for relocation */
X+
X+   omf_start_thread(I386);
X+   omf_thread(CONST_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_CONST);
X+   omf_thread(DATA_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_DATA);
X+   omf_thread(TEXT_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_TEXT);
X+   omf_thread(BSS_TGT_THREAD, TARGET_THREAD, FRM_SI, SDEF_BSS);
X+   omf_thread(TEXT_FRAME_THREAD, FRAME_THREAD, FRM_SI, SDEF_TEXT);
X+   omf_thread(DGROUP_FRAME_THREAD, FRAME_THREAD, FRM_GI, GDEF_DGROUP);
X+   omf_end_thread();
X+
X+   /*
X+    * Emit code.
X+    */
X+
X+   for (fragP = data_frag_root;  fragP;  fragP = fragP -> fr_next)
X+   {
X+       register long int count;
X+       register char * fill_literal;
X+       register long int fill_size;
X+       register fixS * fixP;
X+       register symbolS * symbolP;
X+       int started_fixup;
X+
X+       know( fragP -> fr_type == rs_fill );
X+
X+       if (fragP->fr_fix != 0 || fragP->fr_offset != 0)
X+       {
X+           omf_start_ledata(I386, SDEF_DATA, fragP->fr_address);
X+           if (fragP->fr_fix != 0)
X+               omf_ledata(fragP->fr_literal, (int)fragP->fr_fix);
X+           fill_literal = fragP->fr_literal + fragP -> fr_fix;
X+           fill_size = fragP->fr_var;
X+           count = fragP -> fr_offset;
X+       if ((fragP->fr_fix + count * fill_size) < 1016)
X+       {
X+               for ( ; count; count--)
X+                   omf_ledata(fill_literal, (int)fill_size);
X+       }
X+       else  /* filling will exceed the 1024 byte record size */
X+       {
X+           /* This code assumes that fill_size <= 8 bytes.
X+            * This is infact the case because of
X+            * compatability with other assemblers
X+            */
X+           register int fcount;
X+
X+           fcount = (1016 - fragP->fr_fix) / fill_size;
X+           count -= fcount;
X+           for ( ; fcount > 0; fcount--)
X+                   omf_ledata(fill_literal, (int)fill_size);
X+
X+       }
X+           omf_end_ledata();
X+
X+           /* Emit the relocations for this frag
X+            */
X+
X+           fixP = data_fix_root;  started_fixup = 0;
X+           for ( ;  fixP;  fixP = fixP -> fx_next)
X+           {
X+               if (fixP->fx_frag == fragP && (symbolP = fixP->fx_addsy))
X+               {
X+           int trgt_thrd, frm_thrd;
X+           int external = EXTDEF(symbolP->sy_type);
X+
X+           threads(symbolP->sy_type, &trgt_thrd, &frm_thrd);
X+           if (fixP->fx_pcrel)
X+             frm_thrd = TEXT_FRAME_THREAD;
X+
X+                   if (!started_fixup)
X+                   {
X+                       omf_start_fixup(I386);
X+                       started_fixup++;
X+                   }
X+                   omf_fixup(I386, !fixP->fx_pcrel,
X+                 nbytes_r_length [fixP->fx_size], fixP->fx_where,
X+                 external ? 0 : 1,
X+                 external ? FRM_TRGT : frm_thrd,
X+                 external ? 0 : 1,
X+                 external ? TGT_EI : trgt_thrd,
X+                 1, /* No offset */
X+             0, /* No frame required */
X+                 EXTDEF(symbolP->sy_type) ? symbolP->sy_number : 0,
X+             0);
X+           }
X+           }
X+           if (started_fixup)
X+               omf_end_fixup();
X+
X+       while (count > 0)    /* still sum fill data to emit */
X+       {
X+           unsigned long address;
X+           unsigned int len;
X+
X+               address = fragP->fr_address + fragP->fr_fix +
X+               (fragP->fr_offset - count) * fill_size;
X+               omf_start_ledata(I386, SDEF_DATA, address);
X+               for ( len = 0; count && (len < 1000); count--, len += fill_size)
X+                   omf_ledata(fill_literal, (int)fill_size);
X+               omf_end_ledata();
X+       }
X+       }
X+   }
X+
X+   for (fragP = text_frag_root;  fragP;  fragP = fragP -> fr_next)
X+   {
X+       register long int count;
X+       register char * fill_literal;
X+       register long int fill_size;
X+       register fixS * fixP;
X+       register symbolS * symbolP;
X+       int started_fixup;
X+
X+       know( fragP -> fr_type == rs_fill );
X+
X+       if (fragP->fr_fix != 0 || fragP->fr_offset != 0)
X+       {
X+           omf_start_ledata(I386, SDEF_TEXT, fragP->fr_address);
X+           if (fragP->fr_fix != 0)
X+               omf_ledata(fragP->fr_literal, (int)fragP->fr_fix);
X+           fill_literal = fragP->fr_literal + fragP -> fr_fix;
X+           fill_size = fragP->fr_var;
X+           for (count = fragP -> fr_offset;  count;  count --)
X+               omf_ledata(fill_literal, (int)fill_size);
X+           omf_end_ledata();
X+
X+           /* Emit the relocations for this frag
X+            */
X+
X+           fixP = text_fix_root;  started_fixup = 0;
X+           for ( ;  fixP;  fixP = fixP -> fx_next)
X+           {
X+               if (fixP->fx_frag == fragP && (symbolP = fixP->fx_addsy))
X+               {
X+           int trgt_thrd, frm_thrd;
X+           int external = EXTDEF(symbolP->sy_type);
X+
X+           threads(symbolP->sy_type, &trgt_thrd, &frm_thrd);
X+           if (fixP->fx_pcrel)
X+             frm_thrd = TEXT_FRAME_THREAD;
X+
X+                   if (!started_fixup)
X+                   {
X+                       omf_start_fixup(I386);
X+                       started_fixup++;
X+                   }
X+                   omf_fixup(I386, !fixP->fx_pcrel,
X+                 nbytes_r_length [fixP->fx_size], fixP->fx_where,
X+                 external ? 0 : 1,
X+                 external ? FRM_TRGT : frm_thrd,
X+                 external ? 0 : 1,
X+                 external ? TGT_EI : trgt_thrd,
X+                 1, /* No offset */
X+             0, /* No frame required */
X+                 external ? symbolP->sy_number : 0,
X+             0);
X+           }
X+           }
X+           if (started_fixup)
X+               omf_end_fixup();
X+       }
X+   }
X+
X+ /*  Traverse the symbol chain emitting stabs.
X+  */
X+
X+ #define VAL_OFF offsetof(struct nlist, n_value)
X+
X+   if (flagseen['g'] && stab_symbol_count)
X+   {
X+       long count = 0, ncount = 0;
X+       symbolS *last_startP;
X+       char *temp;
X+       symbolS *fsymP;
X+       int i;
X+       int start_fixup = 0;
X+
X+       omf_start_ledata(I386, SDEF_SYMBOLS, 0);
X+       last_startP = symbol_rootP;
X+       for (symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next)
X+       {
X+      if (symbolP->sy_nlist.n_type & N_STAB)
X+      {
X+             if ((ncount + 1) * sizeof(struct nlist) >= 1016)
X+             {
X+                omf_end_ledata();
X+
X+                /* emit relocations */
X+
X+                start_fixup = 0;
X+            for (i = 0, fsymP=last_startP; i < ncount; fsymP=fsymP->sy_next)
X+            {
X+               if (fsymP->sy_nlist.n_type & N_STAB)
X+           {
X+                      if (fsymP->sy_type & N_TYPE) /* if relocation required */
X+              {
X+                int trgt_thrd, frm_thrd;
X+                int external = EXTDEF(fsymP->sy_type & N_TYPE);
X+
X+                threads(fsymP->sy_type & N_TYPE,&trgt_thrd,&frm_thrd);
X+                if (!start_fixup)
X+                {
X+                            omf_start_fixup(I386);
X+                start_fixup++;
X+                }
X+                omf_fixup(I386, 1, /* segment relative */
X+                   LOC_OFFSET32, i * sizeof(struct nlist) + VAL_OFF,
X+                   external ? 0 : 1,
X+                   external ? FRM_TRGT : frm_thrd,
X+                   external ? 0 : 1,
X+                   external ? TGT_EI : trgt_thrd,
X+                   1, /* No offset */
X+               0, /* No frame required */
X+                   external ? fsymP->sy_number : 0,
X+               0);
X+              }
X+              i++;
X+           }
X+            }
X+            if (start_fixup)
X+                   omf_end_fixup();
X+
X+                /* start new segment */
X+
X+                ncount = 0;  last_startP = symbolP;
X+                omf_start_ledata(I386, SDEF_SYMBOLS, count*sizeof(struct nlist));
X+             }
X+             temp = symbolP->sy_nlist.n_un.n_name;
X+             symbolP->sy_nlist.n_un.n_strx = symbolP->sy_name_offset;
X+             omf_ledata(&(symbolP->sy_nlist), sizeof(struct nlist));
X+             symbolP->sy_nlist.n_un.n_name = temp;
X+            ncount++;  count++;
X+      }
X+       }
X+       omf_end_ledata();
X+       start_fixup = 0;
X+       for (i = 0, fsymP = last_startP; i < ncount; fsymP = fsymP->sy_next)
X+       {
X+          if (fsymP->sy_nlist.n_type & N_STAB)
X+      {
X+             if (fsymP->sy_type & N_TYPE) /* if relocation required */
X+         {
X+           int trgt_thrd, frm_thrd;
X+           int external = EXTDEF(fsymP->sy_type & N_TYPE);
X+
X+           threads(fsymP->sy_type & N_TYPE,&trgt_thrd,&frm_thrd);
X+           if (!start_fixup)
X+               {
X+                  omf_start_fixup(I386);
X+                  start_fixup++;
X+               }
X+           omf_fixup(I386, 1, /* segment relative */
X+              LOC_OFFSET32, i * sizeof(struct nlist) + VAL_OFF,
X+              external ? 0 : 1,
X+              external ? FRM_TRGT : frm_thrd,
X+              external ? 0 : 1,
X+              external ? TGT_EI : trgt_thrd,
X+              1, /* No offset */
X+                   0, /* No frame required */
X+              external ? fsymP->sy_number : 0,
X+           0);
X+         }
X+         i++;
X+      }
X+       }
X+       if (start_fixup)
X+          omf_end_fixup();
X+
X+       count = sizeof(string_byte_count);  ncount = count;
X+       omf_start_ledata(I386, SDEF_TYPES, 0);
X+       omf_ledata(&string_byte_count, sizeof(string_byte_count));
X+       for (symbolP = symbol_rootP; symbolP; symbolP = symbolP -> sy_next)
X+       {
X+          if (symbolP->sy_nlist.n_type & N_STAB && symbolP -> sy_name)
X+      {
X+         int len = strlen(symbolP -> sy_name) + 1;
X+
X+         if (ncount + len > 1016)
X+         {
X+            omf_end_ledata();
X+                omf_start_ledata(I386, SDEF_TYPES, count);
X+            ncount = 0;
X+         }
X+             omf_ledata(symbolP->sy_name, len);
X+         count += len;  ncount += len;
X+      }
X+       }
X+       omf_end_ledata();
X+   }
X+
X+
X+   omf_modend(I386);
X+   output_file_close (out_file_name);
X+
X+ }                /* write_object_file() */
X*** gas-1.38/read.c    Tue Oct 30 13:42:03 1990
X--- read.c    Wed Jul 10 12:53:36 1991
X***************
X*** 711,717 ****
X      int    length;
X
X      /* Some assemblers tolerate immediately following '"' */
X!     if ( s = demand_copy_string( & length ) ) {
X          new_logical_line (s, -1);
X          demand_empty_rest_of_line();
X      }
X--- 711,718 ----
X      int    length;
X
X      /* Some assemblers tolerate immediately following '"' */
X!     if ( s = demand_copy_C_string( & length ) ) {
X!         module_name = s;
X          new_logical_line (s, -1);
X          demand_empty_rest_of_line();
X      }
X***************
X*** 1697,1703 ****
X  void    /* JF was static, but can't be if VAX.C is goning to use it */
X  float_cons(float_type)        /* Worker to do .float etc statements. */
X                  /* Clobbers input_line-pointer, checks end-of-line. */
X!      register float_type;    /* 'f':.ffloat ... 'F':.float ... */
X  {
X    register char *    p;
X    register char        c;
X--- 1698,1704 ----
X  void    /* JF was static, but can't be if VAX.C is goning to use it */
X  float_cons(float_type)        /* Worker to do .float etc statements. */
X                  /* Clobbers input_line-pointer, checks end-of-line. */
X!      register int float_type;    /* 'f':.ffloat ... 'F':.float ... */
X  {
X    register char *    p;
X    register char        c;
X*** gas-1.38/subsegs.c    Thu Oct 11 11:26:23 1990
X--- subsegs.c    Wed Jul 10 09:02:02 1991
X***************
X*** 96,102 ****
X--- 96,106 ----
X    know( SEG_MAXIMUM_ORDINAL == SEG_DIFFERENCE );
X    know( seg_name [(int) SEG_MAXIMUM_ORDINAL + 1] [0] == 0 );
X
X+ #ifdef M_XENIX
X+   obstack_begin( &frags, 1000);
X+ #else
X    obstack_begin( &frags, 5000);
X+ #endif /* M_XENIX */
X    frchain_root = NULL;
X    frchain_now  = NULL;        /* Warn new_subseg() that we are booting. */
X                  /* Fake up 1st frag. */
X*** gas-1.38/write.c    Thu Oct 11 11:26:15 1990
X--- write.c    Wed Jul 10 09:06:47 1991
X***************
X*** 38,43 ****
X--- 38,46 ----
X  #include "write.h"
X  #include "symbols.h"
X
X+ static relax_addressT    relax_align();
X+
X+ #ifndef M_XENIX
X  #ifdef SPARC
X  #include "sparc.h"
X  #endif
X***************
X*** 93,103 ****
X
X  static void    relax_segment();
X  void        emit_segment();
X- static relax_addressT    relax_align();
X  static long int    fixup_segment();
X  #if !defined(SPARC) && !defined(I860)
X  static void        emit_relocations();
X  #endif
X  /*
X   *            fix_new()
X   *
X--- 96,107 ----
X
X  static void    relax_segment();
X  void        emit_segment();
X  static long int    fixup_segment();
X  #if !defined(SPARC) && !defined(I860)
X  static void        emit_relocations();
X  #endif
X+
X+ #endif /* M_XENIX */
X  /*
X   *            fix_new()
X   *
X***************
X*** 146,151 ****
X--- 150,156 ----
X    * seg_fix_rootP = fixP;
X  }
X
X+ #ifndef M_XENIX
X  void
X  write_object_file()
X  {
X***************
X*** 683,688 ****
X--- 688,694 ----
X    VMS_write_object_file(text_siz, data_siz, text_frag_root, data_frag_root);
X  #endif    /* VMS */
X  }                /* write_object_file() */
X+ #endif /* M_XENIX */
X
X  /*
X   *            relax_segment()
X***************
X*** 697,703 ****
X--- 703,711 ----
X   * these frag addresses may not be the same as final object-file addresses.
X   */
X  #ifndef    VMS
X+ #ifndef M_XENIX
X  static
X+ #endif    /* not M_XENIX */
X  #endif    /* not VMS */
X  void
X  relax_segment (segment_frag_root, segment_type)
X***************
X*** 1010,1016 ****
X  /*
X   *            fixup_segment()
X   */
X! static long int
X  fixup_segment (fixP, this_segment_type)
X       register fixS *    fixP;
X       int        this_segment_type; /* N_TYPE bits for segment. */
X--- 1018,1027 ----
X  /*
X   *            fixup_segment()
X   */
X! #ifndef M_XENIX
X! static
X! #endif /* not M_XENIX */
X! long int
X  fixup_segment (fixP, this_segment_type)
X       register fixS *    fixP;
X       int        this_segment_type; /* N_TYPE bits for segment. */
X***************
X*** 1137,1142 ****
X--- 1148,1156 ----
X      }            /* if there was a + symbol */
X        if (pcrel)
X      {
X+ #ifdef M_XENIX
X+       if (add_symbol_N_TYPE != N_UNDF)
X+ #endif
X        add_number -=
X  #ifndef NS32K
X            size +
X***************
X*** 1184,1189 ****
X--- 1198,1204 ----
X  }                /* fixup_segment() */
X
X
X+ #ifndef M_XENIX
X  /* The sparc needs its own emit_relocations() */
X  #if !defined(SPARC) && !defined(I860)
X  /*
X***************
X*** 1244,1249 ****
X--- 1259,1265 ----
X
X  }
X  #endif
X+ #endif /* M_XENIX */
X
X  int
X  is_dnrange(f1,f2)
X*** gas-1.38/xenixomf.c
X--- xenixomf.c    Wed Jul 10 09:02:18 1991
X***************
X*** 0 ****
X--- 1,660 ----
X+ #include <string.h>
X+ #include <stdio.h>
X+ #include "xenixomf.h"
X+ #include "msomf.h"
X+
X+ #ifdef M_XENIX
X+ #  undef i386
X+ #endif
X+
X+ #define MAXRECORDSIZE    (14 * 1024)    /* 1k data => 1024 fixups */
X+ #define I386    1
X+
X+ extern char *out_file_name;
X+
X+ static char chksum = 0;
X+ static unsigned char recordbuff[MAXRECORDSIZE];
X+ static unsigned char *record_ptr;
X+
X+ static void copy_bytes_to_record(p, count)
X+ unsigned char *p;
X+ int count;
X+ {
X+     while (count--)
X+     {
X+         *record_ptr++ = *p;
X+         chksum += *p++;
X+     }
X+ }
X+
X+ static void start_record(type)
X+ unsigned char type;
X+ {
X+     chksum = 0;
X+     record_ptr = recordbuff;
X+     copy_bytes_to_record(&type, 1);
X+     record_ptr += 2;    /* leave space for the record size */
X+ }
X+
X+ static void output_record()
X+ {
X+     int length;
X+     unsigned char b;
X+
X+     length = (record_ptr - recordbuff) + 1; /* 1 for chksum */
X+
X+     /* patch the record length into the header and put -chksum
X+      * at the end of the record.
X+      */
X+
X+     b = (length - 3) & 0xff;  /* -3 as record length excludes type + len */
X+     chksum += b;  recordbuff[1] = b;
X+     b = ((length - 3) >> 8) & 0xff;
X+     chksum += b;  recordbuff[2] = b;
X+     *record_ptr = (unsigned char)(-chksum);
X+
X+     output_file_append (recordbuff, length, out_file_name);
X+ }
X+
X+ static void copy_string_to_record(s)
X+ char *s;
X+ {
X+     unsigned char len;
X+
X+     len = strlen(s);
X+     if (len > OMFNAMELENGTH)
X+     {
X+         char tname[OMFNAMELENGTH+2];
X+
X+         strncpy(tname, s, OMFNAMELENGTH);
X+         tname[OMFNAMELENGTH] = '\0';
X+         fprintf(stderr, "Identifier truncated to %s (%d chars)\n",
X+                 tname, OMFNAMELENGTH);
X+         len = OMFNAMELENGTH;
X+         copy_bytes_to_record(&len, 1);
X+         copy_bytes_to_record(s, OMFNAMELENGTH);
X+     }
X+     else
X+     {
X+         copy_bytes_to_record(&len, 1);
X+         if (len > 0)
X+             copy_bytes_to_record(s, len);
X+     }
X+ }
X+
X+ static void copy_index_to_record(index)
X+ unsigned int index;
X+ {
X+     unsigned char b;
X+
X+     if (index < 128)
X+     {
X+         b = (unsigned char)(index & 0xff);
X+         copy_bytes_to_record(&b, 1);
X+     }
X+     else
X+     {
X+         b = (unsigned char)(((index >> 8) & 0xff) | 0x80);
X+         copy_bytes_to_record(&b, 1);
X+         b = (unsigned char)(index & 0xff);
X+         copy_bytes_to_record(&b, 1);
X+     }
X+ }
X+
X+ static void copy_vint_to_record(value, count)
X+ long value;
X+ int count;
X+ {
X+     unsigned char b;
X+
X+     while (count--)
X+     {
X+         b = (unsigned char)(value & 0xff);
X+         copy_bytes_to_record(&b, 1);
X+         value >>= 8;
X+     }
X+ }
X+
X+ static void copy_word_to_record(value)
X+ unsigned int value;
X+ {
X+     copy_vint_to_record((long)value, 2);
X+ }
X+
X+ static void copy_offset_to_record(i386, value)
X+ int i386;
X+ long value;
X+ {
X+     copy_vint_to_record(value, i386 ? 4 : 2);
X+ }
X+
X+ static void copy_comsize_to_record(value)
X+ long value;
X+ {
X+     unsigned char b;
X+
X+     if (value < 128)
X+         copy_vint_to_record((long)value, 1);
X+     else if (value < 65536L)
X+     {
X+         b = 0x81;
X+         copy_bytes_to_record(&b, 1);
X+         copy_vint_to_record((long)value, 2);
X+     }
X+     else if (value < 16777216L)
X+     {
X+         b = 0x84;
X+         copy_bytes_to_record(&b, 1);
X+         copy_vint_to_record((long)value, 3);
X+     }
X+     else
X+     {
X+         b = 0x88;
X+         copy_bytes_to_record(&b, 1);
X+         copy_vint_to_record((long)value, 4);
X+     }
X+
X+ }
X+
X+ void omf_theadr(name)
X+ unsigned char *name;
X+ {
X+     start_record(MTHEADR);
X+     copy_string_to_record(name);
X+     output_record();
X+ }
X+
X+ void omf_coment(p, count, class)
X+ unsigned char *p;
X+ int count;
X+ unsigned char class;
X+ {
X+     unsigned char attrib;
X+
X+     start_record(MCOMENT);
X+     attrib = 0;        /* Purge and List attributes */
X+     copy_bytes_to_record(&attrib, 1);
X+     copy_bytes_to_record(&class, 1);
X+     copy_bytes_to_record(p, count);
X+     output_record();
X+ }
X+
X+ void omf_extdef(name, type)
X+ unsigned char *name;
X+ {
X+     start_record(MEXTDEF);
X+     copy_string_to_record(name);
X+     copy_bytes_to_record(&type, 1);
X+     output_record();
X+ }
X+
X+ void omf_start_pubdef(i386, group, segment, frame)
X+ int i386;
X+ int group, segment, frame;
X+ {
X+     if (i386)
X+         start_record(MPUB386);
X+     else
X+         start_record(MPUBDEF);
X+
X+     copy_index_to_record(group);
X+     copy_index_to_record(segment);
X+     if (group == 0 && segment == 0)
X+         copy_word_to_record(frame);
X+ }
X+
X+ void omf_pubdef(i386, name, offset, type)
X+ int i386;
X+ unsigned char *name;
X+ int type;
X+ long offset;
X+ {
X+     copy_string_to_record(name);
X+     copy_offset_to_record(i386, offset);
X+     copy_index_to_record(type);
X+ }
X+
X+ void omf_end_pubdef()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_lnames()
X+ {
X+     start_record(MLNAMES);
X+ }
X+
X+ void omf_lnames(name)
X+ unsigned char *name;
X+ {
X+     copy_string_to_record(name);
X+ }
X+
X+ void omf_end_lnames()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_segdef(i386, acbp, frame, offset, seglen, segname, segclass)
X+ int i386;
X+ unsigned char acbp;
X+ unsigned int frame;
X+ unsigned int offset;
X+ long seglen;
X+ unsigned int segname, segclass;
X+ {
X+     unsigned int ovlindex = 0;
X+     if (i386)
X+         start_record(MSEG386);
X+     else
X+         start_record(MSEGDEF);
X+
X+     copy_bytes_to_record(&acbp, 1);
X+     if ((acbp & SD_ALIGN) == SD_ABS)
X+     {
X+         copy_word_to_record(frame);
X+         copy_word_to_record(offset);  /* should be byte - Fix Me */
X+     }
X+     copy_offset_to_record(i386, seglen);
X+     copy_index_to_record(segname);
X+     copy_index_to_record(segclass);
X+     copy_index_to_record(ovlindex);
X+     output_record();
X+ }
X+
X+ void omf_start_grpdef(grpname)
X+ unsigned int grpname;
X+ {
X+     start_record(MGRPDEF);
X+     copy_index_to_record(grpname);
X+ }
X+
X+ void omf_grpdef(segindex)
X+ unsigned int segindex;
X+ {
X+     unsigned char b = 0xff;
X+
X+     copy_bytes_to_record(&b, 1);
X+     copy_index_to_record(segindex);
X+ }
X+
X+ void omf_end_grpdef()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_comdef()
X+ {
X+     start_record(MCOMDEF);
X+ }
X+
X+ void omf_comdef(name, dataseg_type, length, el_size)
X+ unsigned char *name;
X+ unsigned char dataseg_type;
X+ {
X+     unsigned char type = 0;
X+
X+     copy_string_to_record(name);
X+     copy_bytes_to_record(&type, 1);
X+     copy_bytes_to_record(&dataseg_type, 1);
X+
X+     copy_comsize_to_record(length);
X+     if (dataseg_type == TD_CFAR)
X+     {
X+         copy_comsize_to_record(el_size);
X+     }
X+ }
X+
X+ void omf_end_comdef()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_linnum(i386, segindex)
X+ {
X+     unsigned char grpindex = 0;
X+
X+     if (i386)
X+         start_record(MLIN386);
X+     else
X+         start_record(MLINNUM);
X+
X+     copy_bytes_to_record(&grpindex, 1);
X+     copy_index_to_record(segindex);
X+ }
X+
X+ void omf_linnum(i386, line, offset)
X+ int i386;
X+ unsigned int line;
X+ long offset;
X+ {
X+     copy_word_to_record(line);
X+     copy_offset_to_record(i386, offset);
X+ }
X+
X+ void omf_end_linnum()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_thread(i386)
X+ {
X+     if (i386)
X+         start_record(MFIX386);
X+     else
X+         start_record(MFIXUPP);
X+ }
X+
X+ void omf_thread(thread, framethread, method, index)
X+ unsigned char thread;
X+ int framethread;
X+ unsigned char method;
X+ unsigned int index;
X+ {
X+     unsigned char thread_data;
X+
X+     thread_data = thread | (method << TRD_MTHDSHFT);
X+     if (framethread)
X+         thread_data |= TRD_FRAME;
X+     copy_bytes_to_record(&thread_data, 1);
X+
X+     if (framethread)
X+     {
X+         switch (method)
X+         {
X+         case FRM_SI:
X+         case FRM_GI:
X+         case FRM_EI:
X+         case FRM_ABS:
X+             copy_index_to_record(index);
X+             break;
X+         case FRM_LOC:
X+         case FRM_TRGT:
X+             break;
X+         }
X+     }
X+     else
X+         copy_index_to_record(index);
X+ }
X+
X+ void omf_end_thread()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_fixup(i386)
X+ {
X+     if (i386)
X+         start_record(MFIX386);
X+     else
X+         start_record(MFIXUPP);
X+ }
X+
X+ static void generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec,
X+                        frame_index, target_index, offset)
X+ int i386;
X+ int f_thrd;
X+ unsigned int frame;
X+ int t_thrd;
X+ unsigned int trgt;
X+ int t_sec;
X+ unsigned int frame_index, target_index;
X+ long offset;
X+ {
X+     unsigned char fixdat, b;
X+
X+     fixdat = (f_thrd ? FIXDAT_FTHRD : 0) | (frame << FIXDAT_FRSHFT);
X+     fixdat |= (t_thrd ? FIXDAT_TTHRD : 0) | trgt | (t_sec ? FIXDAT_TSCND:0);
X+     copy_bytes_to_record(&fixdat, 1);
X+
X+     if (!f_thrd)
X+     {
X+         switch (frame)
X+         {
X+         case FRM_SI:
X+         case FRM_GI:
X+         case FRM_EI:
X+         case FRM_ABS:
X+             copy_index_to_record(frame_index);
X+             break;
X+         case FRM_LOC:
X+         case FRM_TRGT:
X+             break;
X+         }
X+     }
X+
X+     if (!t_thrd)
X+         copy_index_to_record(target_index);
X+
X+     if (!t_sec)
X+         copy_offset_to_record(i386, offset);
X+ }
X+
X+ void omf_fixup(i386, segrel, loc, data_off, f_thrd, frame, t_thrd, trgt, t_sec,
X+            frame_index, target_index, offset)
X+ int i386, segrel;
X+ unsigned char loc;
X+ unsigned int data_off;
X+ int f_thrd;
X+ unsigned int frame;
X+ int t_thrd;
X+ unsigned int trgt;
X+ int t_sec;
X+ unsigned int frame_index, target_index;
X+ long offset;
X+ {
X+     unsigned int locat = 0x8000;
X+     unsigned char fixdat, b;
X+
X+     locat |= (segrel ? FIX_SEG : 0) | (loc << FIX_LOCSHFT) |
X+          (data_off & FIX_DATAOFF);
X+     b = (locat >> 8) & 0xff;  copy_bytes_to_record(&b, 1);
X+     b = locat & 0xff;  copy_bytes_to_record(&b, 1);
X+     generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
X+             target_index, offset);
X+ }
X+
X+ void omf_end_fixup()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_start_ledata(i386, segindex, start_offset)
X+ int i386;
X+ unsigned int segindex;
X+ long start_offset;
X+ {
X+     if (i386)
X+         start_record(MLED386);
X+     else
X+         start_record(MLEDATA);
X+
X+     copy_index_to_record(segindex);
X+     copy_offset_to_record(i386, start_offset);
X+ }
X+
X+ void omf_ledata(data, count)
X+ unsigned char *data;
X+ int count;
X+ {
X+     copy_bytes_to_record(data, count);
X+
X+ }
X+
X+ void omf_end_ledata()
X+ {
X+     output_record();
X+ }
X+
X+ void omf_main_modend(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
X+              target_index, offset)
X+ int i386;
X+ int f_thrd;
X+ unsigned int frame;
X+ int t_thrd;
X+ unsigned int trgt;
X+ int t_sec;
X+ unsigned int frame_index, target_index;
X+ long offset;
X+ {
X+     unsigned char mtype = 0xc1;
X+
X+     if (i386)
X+         start_record(M386END);
X+     else
X+         start_record(MMODEND);
X+
X+     copy_bytes_to_record(&mtype, 1);
X+
X+     generate_fixdat(i386, f_thrd, frame, t_thrd, trgt, t_sec, frame_index,
X+             target_index, offset);
X+     output_record();
X+ }
X+
X+ void omf_modend(i386)
X+ int i386;
X+ {
X+     unsigned char mtype = 0;
X+
X+     if (i386)
X+         start_record(M386END);
X+     else
X+         start_record(MMODEND);
X+
X+     copy_bytes_to_record(&mtype, 1);
X+     output_record();
X+ }
X+
X+ /** Definitions required to produce a standard Microsoft .o file
X+  */
X+
X+ /** LNAMES, SEGDEF, GRPDEF and COMENT stuff
X+  *
X+  *  NB the following defines must reflect the position of the string in
X+  *  the lnames_tab table.
X+  */
X+
X+ #define    L_BLANK        1
X+ #define    L_DGROUP    2
X+ #define L_UTEXT        3
X+ #define L_CODE        4
X+ #define L_UDATA        5
X+ #define L_DATA        6
X+ #define L_CONST        7
X+ #define L_UBSS        8
X+ #define L_BSS        9
X+ #define L_TYPES        10
X+ #define L_DEBTYP    11
X+ #define L_SYMBOLS    12
X+ #define L_DEBSYM    13
X+ #define L_TSIZE        9
X+ #define L_G_TSIZE    13
X+
X+ char *lnames_tab[] = {
X+     "",
X+     "",
X+     "DGROUP",
X+     "_TEXT",
X+     "CODE",
X+     "_DATA",
X+     "DATA",
X+     "CONST",
X+     "_BSS",
X+     "BSS",
X+     "$$TYPES",
X+     "DEBTYP",
X+     "$$SYMBOLS",
X+     "DEBSYM"
X+ };
X+
X+ struct segtable {
X+     unsigned char attrib;
X+     long length;
X+     unsigned nameindex;
X+     unsigned classindex;
X+ };
X+
X+ /* SEGDEF's */
X+
X+ static struct segtable segt[] = {
X+     {0, NULL, 0, 0},
X+     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UTEXT, L_CODE},
X+     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UDATA, L_DATA},
X+     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_CONST, L_CONST},
X+     {SD_DWORD|SD_PUBLIC|SD_PGRES, 0, L_UBSS, L_BSS},
X+     {SD_BYTE|SD_PGRES, 0, L_SYMBOLS, L_DEBSYM},
X+     {SD_BYTE|SD_PGRES, 0, L_TYPES, L_DEBTYP}
X+ };
X+
X+ /* GRPDEF */
X+
X+ #define GRPTABSIZ 3
X+
X+ unsigned int group_tab[GRPTABSIZ] = {3, 4, 2};
X+
X+ /* COMENTs */
X+
X+ struct comment {
X+     unsigned char class;
X+     unsigned char count;
X+     unsigned char *data;
X+ };
X+
X+ #define NUMFIXEDCOMMENTS 4
X+
X+ static unsigned char gas_comment[] = "gas-1.38.1a";
X+ static unsigned char lib_comment[] = "SLIBCE";
X+ static unsigned char model_comment[] = "3s";
X+ static unsigned char msext_comment[] = {1, 0x43, 0x56};
X+
X+ struct comment fix_cmnt[NUMFIXEDCOMMENTS] = {
X+     {0, 8, gas_comment},
X+     {0x9f, 6, lib_comment},
X+     {0x9d, 2, model_comment},
X+     {0xa1, 3, msext_comment}
X+ };
X+
X+ void omf_initialize_a_out(name, text_size, data_size, bss_size, const_size,
X+               gdb, syms_size, str_size)
X+ unsigned char *name;
X+ long text_size, data_size, bss_size, const_size;
X+ int gdb;
X+ long syms_size, str_size;
X+ {
X+     int i;
X+
X+     omf_theadr(name);
X+
X+     /* static comments */
X+
X+     for (i = 0; i < NUMFIXEDCOMMENTS; i++)
X+       omf_coment(fix_cmnt[i].data, fix_cmnt[i].count, fix_cmnt[i].class);
X+
X+     /* LNAMES */
X+
X+     omf_start_lnames();
X+     for (i = 1; i <= (gdb ? L_G_TSIZE : L_TSIZE); i++)
X+         omf_lnames(lnames_tab[i]);
X+     omf_end_lnames();
X+
X+     /* SEGDEFS */
X+
X+     segt[SDEF_TEXT].length = text_size;
X+     segt[SDEF_DATA].length = data_size;
X+     segt[SDEF_BSS].length = bss_size;
X+     segt[SDEF_CONST].length = const_size;
X+     if (gdb)
X+     {
X+         segt[SDEF_SYMBOLS].length = syms_size;
X+         segt[SDEF_TYPES].length = str_size;
X+     }
X+     for (i = 1; i <= (gdb ? SDEF_G_SIZE : SDEF_SIZE); i++)
X+         omf_segdef(I386, segt[i].attrib, 0, 0L, segt[i].length,
X+                segt[i].nameindex, segt[i].classindex);
X+     /* DGROUP */
X+
X+     omf_start_grpdef(L_DGROUP);
X+     for (i = 0; i < GRPTABSIZ; i++)
X+         omf_grpdef(group_tab[i]);
X+     omf_end_grpdef();
X+ }
X*** gas-1.38/xenixomf.h
X--- xenixomf.h    Wed Jul 10 09:02:21 1991
X***************
X*** 0 ****
X--- 1,140 ----
X+
X+ /* Defines to map a.out definitions to OMF style definitions
X+  */
X+ #define    PUBLICDATA    (N_DATA|N_EXT)
X+ #define    PUBLICTEXT    (N_TEXT|N_EXT)
X+ #define    PUBLICABS    (N_ABS|N_EXT)
X+ #define COMMDEF(x)    ((x) == (N_UNDF|N_EXT))
X+ #define PRIVDATA    (N_DATA)
X+ #define PRIVTEXT    (N_TEXT)
X+ #define PRIVBSS        (N_BSS)
X+ #define EXTERNAL    (N_UNDF)
X+ #define PUBLIC(x)    ((x)==PUBLICDATA || (x)==PUBLICTEXT || (x)==PUBLICABS)
X+ #define EXTDEF(x)    ((x)==EXTERNAL || COMMDEF(x))
X+ #define PRIVATE(x)    ((x)==PRIVDATA || (x)==PRIVTEXT || (x)==PRIVBSS)
X+
X+
X+ #define MTHEADR        0x80    /* module header */
X+ #define MCOMENT        0x88    /* comment */
X+ #define MMODEND        0x8a    /* module end */
X+ #define M386END        0x8b    /* 32 bit module end */
X+ #define MEXTDEF        0x8c    /* external definition */
X+ #define MTYPDEF        0x8e    /* type definition */
X+ #define MPUBDEF        0x90    /* public definition */
X+ #define MPUB386        0x91    /* 32 bit public definition */
X+ #define MLINNUM        0x94    /* source line number */
X+ #define MLIN386        0x95    /* 32 bit source line number */
X+ #define MLNAMES        0x96    /* name list */
X+ #define MSEGDEF        0x98    /* segment definition */
X+ #define MSEG386        0x99    /* 32 bit segment definition */
X+ #define MGRPDEF        0x9a    /* group definition */
X+ #define MFIXUPP        0x9c    /* fix up previous data image */
X+ #define MFIX386        0x9d    /* fix up previous 32 bit data image */
X+ #define MLEDATA        0xa0    /* logical data image */
X+ #define MLED386        0xa1    /* 32 bit logical data image */
X+ #define    MCOMDEF        0xb0    /* communal names definition */
X+
X+ /* The maximum length of an identifier.
X+  */
X+
X+ #define OMFNAMELENGTH    127
X+
X+ /* alignment required
X+  */
X+
X+ #define SD_ABS        0x00        /* absolute */
X+ #define SD_BYTE        0x20        /* byte */
X+ #define SD_WORD        0x40        /* word */
X+ #define SD_PARA        0x60        /* paragraph */
X+ #define SD_PAGE        0x80        /* page */
X+ #define SD_DWORD    0xa0        /* double word */
X+ #define SD_LTL        0xc0        /* load-time locatable */
X+ #define SD_ALIGN    0xe0        /* alignment mask */
X+ #define SD_ASHIFT    5        /* alignment shift */
X+
X+ /* segment combine classes */
X+
X+ #define SD_PRIV        0x00        /* private, can't be combined */
X+ #define SD_HCOMM    0x04        /* common, place in high mem */
X+ #define SD_PUBLIC    0x08        /* public, sequential */
X+ #define SD_BAD        0x0c        /* undefined */
X+ #define SD_C4        0x10        /* not used */
X+ #define SD_STACK    0x14        /* stack segment */
X+ #define SD_COMM        0x18        /* common segment */
X+ #define SD_RCOMM    0x1c        /* not used, reverse common segment */
X+ #define SD_COMBO    0x1c        /* combine mask */
X+ #define SD_CSHIFT    2        /* combine shift */
X+ #define SD_PGRES    0x01        /* page resident */
X+ #define SD_64K        0x02        /* segment size is exactly 64k */
X+
X+ /* BSSDEF record definitions
X+  */
X+
X+ #define    TD_CNEAR    0x62        /* near .comm variable */
X+ #define    TD_CFAR        0x61        /* far .comm variable */
X+
X+ /* COMENT record definitions
X+  */
X+
X+ #define     CMT_PURGE    0x80        /* comment can be purged */
X+ #define  CMT_LIST    0x40        /* don't list when listing comments */
X+
X+ /* FIXUP record definitions
X+  */
X+
X+ #define  FIX_FIXUP    0x80        /* fixup is a fixup (else thread def) */
X+ #define  TRD_FRAME    0x40        /* thread def for a frame (else tgt) */
X+ #define  TRD_MTHDSHFT    2        /* frame / target method shift */
X+ #define  TRD_MTHDMSK    0x1c        /* frame / target method mask */
X+ #define  TRD_THRED    0x03        /* thread number mask */
X+
X+ /* Target method defines.  0 - 3 are primary, they include an offset, while
X+  * 4 - 7 or secondary, the offset 0 and not specified.
X+  */
X+
X+ #define  TGT_SI        0        /* target is Segment Index(N) + M */
X+ #define  TGT_GI        1        /* target is Group Index(N) + M */
X+ #define  TGT_EI        2        /* target is External Index(N) + M */
X+ #define  TGT_ABS    3        /* target is absolute frame N + N */
X+ #define  TGT_SI_0    4        /* target is Segment Index(N) + 0 */
X+ #define  TGT_GI_0    5        /* target is Group Index(N) + 0 */
X+ #define  TGT_EI_0    6        /* target is External Index(N) + 0 */
X+ #define  TGT_ABS_0    7        /* target is Absolute Segmnent N + 0 */
X+
X+ /* Frame fixup method
X+  */
X+
X+ #define  FRM_SI        0        /* Frame is Segment index(N) */
X+ #define  FRM_GI        1        /* Frame is Group index(N) */
X+ #define  FRM_EI        2        /* Frame is External index(N) */
X+ #define  FRM_ABS    3        /* Frame is Absolute frame(N) */
X+ #define  FRM_LOC    4        /* Frame is LSEG of LOCATION */
X+ #define  FRM_TRGT    5        /* Frame is the frame of the target */
X+
X+ /* FIXUP fixdat field definitions
X+  */
X+
X+ #define  FIX_SEG    0x4000        /* Fixup is seg relative (else self) */
X+ #define  FIX_24BIT    0x2000        /* Fixup has 24b tgt disp (NOT USED) */
X+ #define  FIX_LOCMSK    0x3c00        /* Fixup location type mask */
X+ #define  FIX_LOCSHFT    10        /* Fixup location type shift */
X+ #define  FIX_DATAOFF    0x3ff        /* location in prev data rec of fixup */
X+ #define  FIXDAT_FTHRD    0x80        /* Fixup frame by thread else direct */
X+ #define  FIXDAT_FRAME    0x70        /* Frame thread or method mask */
X+ #define  FIXDAT_FRSHFT    4        /* Frame thread or method shift */
X+ #define  FIXDAT_TTHRD    0x08        /* Fixup target by thread else direct */
X+ #define  FIXDAT_TSCND    0x04        /* Primary or secondary target method */
X+ #define  FIXDAT_TRGT    0x03        /* Target thread or method mask */
X+
X+ /* Location type definitions
X+  */
X+
X+ #define  LOC_LOBYTE    0        /* low 8 bits */
X+ #define  LOC_OFFSET    1        /* 16 bit offset */
X+ #define  LOC_BASE    2        /* 16 bit frame number */
X+ #define  LOC_POINTER    3        /* 32 bit pointer */
X+ #define  LOC_HIBTE    4        /* second 8 bits */
X+ #define  LOC_OFFSETL    5        /* 16 bit offset (liner resolved) */
X+ #define  LOC_OFFSET32    9        /* 32 bit offset */
X+ #define  LOC_POINTER48    11        /* 48 bit pointer */
X+ #define  LOC_OFFSETL32    13        /* 32 bit offset (liner resolved) */
X
END_OF_FILE
  if test 47292 -ne `wc -c <'gas-1.38.pch'`; then
    echo shar: \"'gas-1.38.pch'\" unpacked with wrong size!
  fi
  # end of 'gas-1.38.pch'
fi
echo shar: End of archive.
exit 0
--
[e-mail]        | Phone:  [phone] x153
Snr Software Engineer, Robobar Ltd. | Fax:    [phone] (G3)
22 Wadsworth Road, Perivale.        |
Middx., UB6 7JD ENGLAND.            | ...!ukc!robobar!steve

exit 0 # Just in case...
--
Kent Landfield                   INTERNET: [e-mail]
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    [phone]         FAX:      [phone]
Please send comp.sources.misc-related mail to [e-mail].